{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "    <img src=\"./images/mlfasp.png\">\n",
    "</center>\n",
    "\n",
    "#### Prof. Dr. -Ing. Gerald Schuller <br> Jupyter Notebook: Renato Profeta\n",
    "\n",
    "[Applied Media Systems Group](https://www.tu-ilmenau.de/en/applied-media-systems-group/) <br>\n",
    "[Technische Universität Ilmenau](https://www.tu-ilmenau.de/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Neural Network as Function Approximator, Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/eg6nZJz05eA?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/eg6nZJz05eA?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a neural network to approximate a function:\n",
    "$$\\large\n",
    "y=f(x)$$\n",
    "\n",
    "In our simple example *x* is a (1-dimensional) sample, and *y* is the (also 1-dimensional) target (also called regression).\n",
    "\n",
    "This function could be, for instance, an audio signal like a tone, which would be a sinusoidal function. Here, *x* would be the time dimension, and *y* would a sample from or to the sound card.\n",
    "\n",
    "In Pytorch we have a `torch.sin()` function, which directly produces a torch tensor, and also a `torch.randn()` function, which produces random numbers according to a gaussian distribution with zero mean and unit variance. We can use this to simulate microphone and pickup noise.\n",
    "\n",
    "We generate our target function with:\n",
    "\n",
    "```python\n",
    "N=40 #number of samples in our signal\n",
    "#Training set:\n",
    "#The x input here is the time:\n",
    "X=torch.arange(0,N,1.0) #generates N time steps for X\n",
    "X=X.view(N,1) #adding the last dimension for the signal (1 sample each),\n",
    "#first dimension for the batch of size N\n",
    "Y=torch.sin(X*3.14/N*2)+torch.randn(X.shape)*0.1\n",
    "#2 periods of the sinusoid in our training set, plus noise```\n",
    "\n",
    "Often we want our network to interpolate the function between the training samples, and also to extrapolate beyond the training samples. Hence we construct a validation set which has the *X* samples between the integer values of the training set, and extend it to beyond the length of the training set. To see how robust our network is against the noise in the training set, we also add new noise.\n",
    "\n",
    "```python\n",
    "#Validation set, to test generalization, with new noise:\n",
    "Xval=torch.arange(0.5,2*N,1.0) #generates 2N time steps for X for extrapolation beyond N,\n",
    "#shifted by 0.5 compared to training set,\n",
    "#for interpolation between the original sample points.\n",
    "#print(\"Xval=\", Xval)\n",
    "Xval=Xval.view(2*N,1)\n",
    "#Validation Target:\n",
    "Yval=torch.sin(Xval*3.14/N*2)+torch.randn(Xval.shape)*0.1```\n",
    "\n",
    "Now we have to decide what kind of network to use. We try to find one which is as simple as possible for the task. We choose a structure which is in principle able to approximate the function piece-wise. We use a number of nodes in the network, and each node is in effect \"responsible\" for a piece of the function. We can do this with a 3-layer fully connected network with activation function (see also:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide_input": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"http://deeplearning.stanford.edu/tutorial/supervised/MultiLayerNeuralNetworks\" width=\"900\" height=\"600\"></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe src=\"http://deeplearning.stanford.edu/tutorial/supervised/MultiLayerNeuralNetworks\" width=\"900\" height=\"600\"></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The first layer is the **input layer**, which takes 1 input sample of *X*, then distributes this sample to N **\"hidden\" nodes**, with weights, each node then has a bias which basically \"activates\" it for certain value ranges of *X*, and the activation function, for instance the Sigmoid function, which is mainly \"active\" in the input range of -4 to 4, followed by weights to the **output layer**, which in our case is simply one node which sums up all the inputs from the hidden nodes, with weights but with no activation function.\n",
    "\n",
    "This can be seen in the following picture:\n",
    "<figure>\n",
    "<img src='./images/02_01_neuralNetsAppro.png' width='600'>\n",
    "<figcaption>Figure: Our neural network for function approximation.</figcaption>\n",
    "</figure>\n",
    "\n",
    "We define our 3-layer neural network with the following class in Pytorch:\n",
    "\n",
    "```python\n",
    "Nodes=10 #This results in a smooth interpolation\n",
    "#Nodes=80 #this can result in over-fitting\n",
    "\n",
    "#A 2-layer fully connected network, 1 input (time value), \n",
    "#hidden layer has N nodes, 1 output (function value).\n",
    "\n",
    "class LinNet(nn.Module):\n",
    "    #define and initialize the layers:\n",
    "    def __init__(self):\n",
    "    super(LinNet, self).__init__()\n",
    "    # Define the model.\n",
    "    #https://pytorch.org/docs/stable/nn.html?highlight=linear#torch.nn.Linear\n",
    "    \n",
    "    # Generate a fully connected linear neural network model, \n",
    "    #2 layers, bias\n",
    "    # returns: Trainable object\n",
    "    self.layer1=nn.Sequential(nn.Linear(in_features=1,out_features=Nodes, bias=True))\n",
    "    self.layer2=nn.Sequential(nn.Linear(in_features=Nodes,out_features=1, bias=True))\n",
    "    \n",
    "    #self.act = nn.LeakyReLU() #non-linear activation function\n",
    "    #self.act = nn.ReLU() #non-linear activation function\n",
    "    #self.act = nn.Hardtanh() #non-linear activation function\n",
    "    self.act = nn.Sigmoid() #non-linear activation function\n",
    "    \n",
    "    #Putting the network together:\n",
    "    def forward(self, x):\n",
    "    out = self.layer1(x)\n",
    "    #print(\"out.shape=\", out.shape)\n",
    "    out = self.act(out) #comment out if not desired\n",
    "    #print(\"out.shape=\", out.shape)\n",
    "    out = self.layer2(out)\n",
    "    #print(\"out.shape=\", out.shape)\n",
    "    return out```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Then in the main section, we first generate the training and validation set, and we instantiate and initialize the model, which is initialized with random weight values:\n",
    "```python\n",
    "#input tensor, type torch tensor:\n",
    "#Indices: batch, additional dimensions, features or signal dimension. \n",
    "#Here: 1 batch, 3 samples, signal dimension 2:\n",
    "#Training set:\n",
    "#The x input here is the time:\n",
    "X=torch.arange(0,N,1.0) #generates N time steps for X\n",
    "X=X.view(N,1) #adding the last dimension for the signal (1sample each), first dimension for the batch\n",
    "print(\"X.shape\", X.shape)\n",
    "#Target here is the (noisy) function value, a sine function + normal distributed random values:\n",
    "#Y=torch.sin(X)+torch.empty(X.shape).normal_(std=0.5)\n",
    "Y=torch.sin(X*3.14/N*2)+torch.randn(X.shape)*0.1\n",
    "Y=Y.view(N,1)\n",
    "print(\"Y.shape\", Y.shape)\n",
    "\n",
    "#Validation set, to test generalization, with new noise:\n",
    "Xval=torch.arange(0,2*N,1.0) #generates 2N time steps for X\n",
    "Xval=Xval.view(2*N,1)\n",
    "#Validation Target:\n",
    "Yval=torch.sin(Xval*3.14/N*2)+torch.randn(Xval.shape)*0.1\n",
    "Yval=Yval.view(2*N,1)\n",
    "#create network object:\n",
    "model = LinNet().to(device)\n",
    "#Before training:\n",
    "Ypred=model(X) #the model produces prediction output\n",
    "print(\"Ypred.shape=\", Ypred.shape)\n",
    "weights = model.state_dict() #read obtained weights\n",
    "print(\"initial weights=\", weights) #see the random\n",
    "initialization of the weights```\n",
    "\n",
    "Then we define the loss function and execute the optimizer:\n",
    "\n",
    "```python\n",
    "print(\"Define loss function:\")\n",
    "loss_fn = nn.MSELoss() #mean squared error loss\n",
    "print(\"Define optimizer:\")\n",
    "#learning_rate = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "#optimizer = torch.optim.SGD(model.parameters(),lr=0.1)\n",
    "\n",
    "print(\"Optimizing:\")\n",
    "for epoch in range(10000):\n",
    "    Ypred=model(X) #the model produces prediction output\n",
    "    loss=loss_fn(Ypred, Y) #prediction and target compared by loss\n",
    "    if epoch%1000==0:\n",
    "        print(epoch, loss.item()) #print current loss value\n",
    "    optimizer.zero_grad() #optimizer sets previous gradients to zero\n",
    "    loss.backward() #optimizer computes new gradients\n",
    "    optimizer.step() #optimizer updates weights\n",
    "```\n",
    "\n",
    "Now we can compute the resulting loss value on the training set and validation set, and plot the obtained learned function in comparison to the (noisy) target function for training and validation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "For plotting we need numpy arrays, hence we need to convert from pytorch tensors to numpy arrays, which we do with the function `.detach().numpy()`.\n",
    "\n",
    "```python\n",
    "Ypred=model(X) # Make Predictions based on the obtained weights\n",
    "#print(\"Ypred training set=\", Ypred)\n",
    "loss=loss_fn(Ypred, Y)\n",
    "print(\"Loss on trainig set:\", loss.detach().numpy())\n",
    "plt.plot(X.detach().numpy()[:,0],Y.detach().numpy()[:,0])\n",
    "plt.plot(X.detach().numpy()[:,0],Ypred.detach().numpy()[:,0])\n",
    "plt.legend(('Training Target', 'Prediction Output'))\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Training Result')\n",
    "plt.show()\n",
    "Yvalpred=model(Xval) # Make Predictions based on the obtained weights\n",
    "#print(\"Y validation set=\", Yvalpred.detach().numpy())\n",
    "loss=loss_fn(Yvalpred[:N,:], Yval[:N,:])\n",
    "print(\"Loss on validation set:\", loss.detach().numpy())\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yval.detach().numpy()[:,0])\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yvalpred.detach().numpy()[:,0])\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Generalization on Validation Set with Interpolation and Extrapolation')\n",
    "plt.legend(('Validation Target', 'Prediction Output'))\n",
    "plt.show()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/idU5m3sNI28?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/idU5m3sNI28?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "__author__ = 'Gerald Schuller'\n",
    "__copyright__ = 'G.S.'\n",
    "\n",
    "\"\"\"\n",
    "Simple program to use a fully connected linear neural network layer as a 1-dimensional faunction y=f(x) approximator.\n",
    "This could be for instance an audio signal, x would be the time, y would be the audio signal value.\n",
    "Gerald Schuller, Dec. 2019.\n",
    "---------------------------------------------------------------------------------------------\n",
    "Ported to Jupyter Notebook by Renato Profeta, August, 2020\n",
    "\"\"\"\n",
    "\n",
    "import torch \n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "device='cpu'\n",
    "#device='cuda'\n",
    "\n",
    "N=40 #number of samples in our signal\n",
    "Nodes=10 #Number of Nodes in the hidden layer. This results in a smooth interpolation\n",
    "#Nodes=80  #this can result in over-fitting\n",
    "\n",
    "#A 2-layer fully connected network, 1 input (time value), hidden layer has \"Nodes\" nodes, 1 output (function value).\n",
    "\n",
    "class LinNet(nn.Module):\n",
    "    #define and initialize the layers:\n",
    "    def __init__(self):\n",
    "        super(LinNet, self).__init__()\n",
    "        # Define the model. \n",
    "        #https://pytorch.org/docs/stable/nn.html?highlight=linear#torch.nn.Linear  \n",
    "        # Generate a fully connected linear neural network model, 2 layers, bias\n",
    "        # returns: Trainable object\n",
    "        self.layer1=nn.Sequential(nn.Linear(in_features=1, out_features=Nodes, bias=True))\n",
    "        self.layer2=nn.Sequential(nn.Linear(in_features=Nodes, out_features=1, bias=True))\n",
    "      \n",
    "        #self.act = nn.LeakyReLU() #non-linear activation function\n",
    "        #self.act = nn.ReLU() #non-linear activation function\n",
    "        #self.act = nn.Hardtanh() #non-linear activation function\n",
    "        self.act = nn.Sigmoid() #non-linear activation function\n",
    "      \n",
    "    #Putting the network together:\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        out = self.act(out)  #comment out if not desired\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        out = self.layer2(out)\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide_input": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of input samples: 40 number of nodes: 10\n",
      "X.shape torch.Size([40, 1])\n",
      "Y.shape torch.Size([40, 1])\n",
      "Ypred.shape= torch.Size([40, 1])\n",
      "initial weights= OrderedDict([('layer1.0.weight', tensor([[ 0.4357],\n",
      "        [ 0.7791],\n",
      "        [-0.4456],\n",
      "        [ 0.9313],\n",
      "        [-0.6877],\n",
      "        [ 0.5454],\n",
      "        [-0.3959],\n",
      "        [ 0.1250],\n",
      "        [ 0.3040],\n",
      "        [ 0.2709]])), ('layer1.0.bias', tensor([-0.5630, -0.6978, -0.2987,  0.7948, -0.2261, -0.3942,  0.6254, -0.6560,\n",
      "         0.5921,  0.4252])), ('layer2.0.weight', tensor([[-0.1172,  0.2365, -0.1195, -0.2363,  0.1819, -0.0191,  0.0920, -0.1297,\n",
      "         -0.2036, -0.1551]])), ('layer2.0.bias', tensor([-0.2262]))])\n",
      "Define loss function:\n",
      "Define optimizer:\n",
      "Optimizing:\n",
      "0 1.1084243059158325\n",
      "1000 0.122523233294487\n",
      "2000 0.062138717621564865\n",
      "3000 0.0500008650124073\n",
      "4000 0.045239225029945374\n",
      "5000 0.042137157171964645\n",
      "6000 0.03921492397785187\n",
      "7000 0.012872174382209778\n",
      "8000 0.010716227814555168\n",
      "9000 0.010322349146008492\n",
      "Loss on trainig set: 0.010162214\n",
      "Loss on validation set: 0.011946008\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of input samples:\", N, \"number of nodes:\", Nodes)\n",
    "#input tensor, type torch tensor:\n",
    "#Indices: batch, additional dimensions, features or signal dimension. Here: 1 batch, 3 samples, signal dimension 2: \n",
    "#Training set:\n",
    "#The x input here is the time:\n",
    "X=torch.arange(0,N,1.0) #generates N time steps for X\n",
    "X=X.view(N,1) #adding the last dimension for the signal (1 sample each), first dimension for the batch of size N\n",
    "print(\"X.shape\", X.shape)\n",
    "#Target here is the (noisy) function value, a sine function + normal distributed random values:\n",
    "#Y=torch.sin(X)+torch.empty(X.shape).normal_(std=0.5)\n",
    "Y=torch.sin(X*3.14/N*2)+torch.randn(X.shape)*0.1\n",
    "#2 periods of the sinusoid in our training set, plus noise\n",
    "#Y=Y.view(N,1)\n",
    "print(\"Y.shape\", Y.shape)\n",
    "#Validation set, to test generalization, with new noise:\n",
    "Xval=torch.arange(0.5,2*N,1.0) #generates 2N time steps for X for extrapolation beyond N,\n",
    "#shifted by 0.5 compared to training set, \n",
    "#for interpolation between the original sample points.\n",
    "#print(\"Xval=\", Xval)\n",
    "Xval=Xval.view(2*N,1)\n",
    "#Validation Target:\n",
    "Yval=torch.sin(Xval*3.14/N*2)+torch.randn(Xval.shape)*0.1\n",
    "#Yval=Yval.view(2*N,1)\n",
    "   \n",
    "#create network object:\n",
    "model = LinNet().to(device)\n",
    "#Before training:\n",
    "Ypred=model(X) #the model produces prediction output\n",
    "print(\"Ypred.shape=\", Ypred.shape)\n",
    "weights = model.state_dict()   #read obtained weights\n",
    "print(\"initial weights=\", weights)  #see the random initialization of the weights \n",
    "   \n",
    "#print(\"model.parameters()=\", model.parameters()) \n",
    "   \n",
    "print(\"Define loss function:\")\n",
    "loss_fn = nn.MSELoss() #mean squared error loss\n",
    "   \n",
    "print(\"Define optimizer:\")\n",
    "#learning_rate = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "#optimizer = torch.optim.SGD(model.parameters(),lr=0.1)\n",
    "print(\"Optimizing:\")\n",
    "for epoch in range(10000):\n",
    "    Ypred=model(X) #the model produces prediction output\n",
    "    loss=loss_fn(Ypred, Y) #prediction and target compared by loss\n",
    "    if epoch%1000==0:\n",
    "        print(epoch, loss.item()) #print current loss value\n",
    "    optimizer.zero_grad() #optimizer sets previous gradients to zero\n",
    "    loss.backward() #optimizer computes new gradients\n",
    "    optimizer.step() #optimizer updates weights\n",
    "       \n",
    "Ypred=model(X) # Make Predictions based on the obtained weights \n",
    "#print(\"Ypred training set=\", Ypred) \n",
    "loss=loss_fn(Ypred, Y)\n",
    "print(\"Loss on trainig set:\", loss.detach().numpy())\n",
    "\n",
    "Yvalpred=model(Xval) # Make Predictions based on the obtained weights \n",
    "#print(\"Y validation set=\", Yvalpred.detach().numpy()) \n",
    "loss=loss_fn(Yvalpred[:N,:], Yval[:N,:])\n",
    "print(\"Loss on validation set:\", loss.detach().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Part of the printouts are the initial weights before the optimization. They are randomly initialized. They are obtained in the program with the lines:\n",
    "\n",
    "```python\n",
    "weights = model.state_dict() #read obtained weights\n",
    "print(\"initial weights=\", weights) #see the random initialization of the weights```\n",
    "\n",
    "It shows a dictionary of weights and biases. We get a printout like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('layer1.0.weight',\n",
       "              tensor([[ 0.2415],\n",
       "                      [ 0.4047],\n",
       "                      [-0.1126],\n",
       "                      [ 1.2180],\n",
       "                      [-0.2518],\n",
       "                      [ 0.3115],\n",
       "                      [-0.2332],\n",
       "                      [ 0.2300],\n",
       "                      [ 0.0528],\n",
       "                      [ 0.0581]])),\n",
       "             ('layer1.0.bias',\n",
       "              tensor([-6.1918, -1.1939,  4.0242,  2.5634,  4.6787, -4.4766,  4.9360, -4.1202,\n",
       "                      -0.3480, -1.1558])),\n",
       "             ('layer2.0.weight',\n",
       "              tensor([[-0.6395,  1.1527, -4.2448,  0.1207,  2.1938,  0.7608,  1.6130, -0.3682,\n",
       "                        0.2043,  0.3181]])),\n",
       "             ('layer2.0.bias', tensor([-0.0184]))])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Observe the data format. The first dictionary entry is `layer1.0.weight`, which is a 2-dimensional tensor or matrix.\n",
    "This represents the matrix 'A' of the first linear layer of our network. Look at the master documentation of pytorch at:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://pytorch.org/docs/stable/nn.html#linear-layers\" width=\"900\" height=\"600\"></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe src=\"https://pytorch.org/docs/stable/nn.html#linear-layers\" width=\"900\" height=\"600\"></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Remember that its equation was:\n",
    "\n",
    "$$\\large\n",
    "y=x \\cdot A^T + b $$\n",
    "\n",
    "In our case  \"*x*\"  consists of just 1 feature (it is 1- dimensional), and we have *N* output features (or nodes).\n",
    "Compare with the network picture in the first part. Hence \"A\" must have 1 column of N entries, which is what we observe.\n",
    "\n",
    "After that we see `layer1.0.bias`, which is the bias vector with *N* entries, one bias entry for each output node.\n",
    "\n",
    "Then we have `layer2.0.weight`, which are the weights for the next layer, which has N input features and one output feature (the approximated function value). Hence it has one row with N elements.\n",
    "\n",
    "Finally we have the bias for this layer. It has only one entry, since it only contains one node.\n",
    "\n",
    "Then the optimization runs, and we obtain the losses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "So the loss on the validation set is somewhat higher than for the training, but less than a factor of 2, which is not too bad.\n",
    "\n",
    "If we increase the number of nodes to 80 or 100, we will observe that the loss on the training set will go down, but the loss on the validation set goes up, which is a sign of **overfitting**.\n",
    "\n",
    "Also try the activation function **\"LeakyReLu\"** for this case of 80 Nodes. It leads to a similar loss. Now try **\"ReLu\"**, and  you will find that the optimizer has a much harder time to find a good solution, because of the **vanishing gradient** of the ReLu activation function for negative inputs.\n",
    "\n",
    "The function plot for the 10 Node training set is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(X.detach().numpy()[:,0],Y.detach().numpy()[:,0])\n",
    "plt.plot(X.detach().numpy()[:,0],Ypred.detach().numpy()[:,0])\n",
    "plt.legend(('Training Target', 'Prediction Output'))\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Training Result')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We see that we get indeed a smoothed version of the training set, which means our network is somewhat robust against the noise on the training set.\n",
    "\n",
    "The plot for the validation set is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yval.detach().numpy()[:,0])\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yvalpred.detach().numpy()[:,0])\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Generalization on Validation Set with Interpolation and Extrapolation')\n",
    "plt.legend(('Validation Target', 'Prediction Output'))\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We see that we have a good interpolation on the X range of the training set, but the extrapolation beyond this training range is not really working.\n",
    "\n",
    "The resulting function from the network is the sum of the functions of the N nodes.\n",
    "\n",
    "To see the functions of the individual nodes, we can just keep their weight unchanged, set the others to zero, and plot the resulting function. For that we make mask with zeros for the weights of layer 2, except for one node, and plot the function. Then we repeat this for every node in a \"for\" loop,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weights= OrderedDict([('layer1.0.weight', tensor([[ 0.2415],\n",
      "        [ 0.4047],\n",
      "        [-0.1126],\n",
      "        [ 1.2180],\n",
      "        [-0.2518],\n",
      "        [ 0.3115],\n",
      "        [-0.2332],\n",
      "        [ 0.2300],\n",
      "        [ 0.0528],\n",
      "        [ 0.0581]])), ('layer1.0.bias', tensor([-6.1918, -1.1939,  4.0242,  2.5634,  4.6787, -4.4766,  4.9360, -4.1202,\n",
      "        -0.3480, -1.1558])), ('layer2.0.weight', tensor([[-0.6395,  1.1527, -4.2448,  0.1207,  2.1938,  0.7608,  1.6130, -0.3682,\n",
      "          0.2043,  0.3181]])), ('layer2.0.bias', tensor([-0.0184]))])\n",
      "model.state_dict()['layer2.0.weight']= tensor([[-0.6395,  1.1527, -4.2448,  0.1207,  2.1938,  0.7608,  1.6130, -0.3682,\n",
      "          0.2043,  0.3181]])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "weights = model.state_dict()   #read obtained weights\n",
    "print(\"weights=\", weights)\n",
    "#Weights of layer 2:\n",
    "layer2weights=model.state_dict()['layer2.0.weight'].clone() #clone(), otherwise it is just a pointer!\n",
    "print(\"model.state_dict()['layer2.0.weight']=\", layer2weights)\n",
    "   \n",
    "#The resulting function from the network is the sum of the functions of the N nodes.\n",
    "#To see the functions of the individual nodes, we can just keep their weight unchanged, \n",
    "#set the others to zero, and plot the resulting function.\n",
    "#For that we make mask with zeros for the weights of layer 2, except for one node:\n",
    "\n",
    "plt.figure(figsize=(10,8))\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Basis Functions of the Network')\n",
    "\n",
    "for node in range(0,Nodes):\n",
    "    weightmask=torch.zeros(layer2weights.shape) #mask with all zeros for output layer, except one.\n",
    "    weightmask[0,node]=1.0 #node \"node\" unchanged\n",
    "    #print(\"weightmask\",weightmask)\n",
    "    #print(\"layer2weights=\",layer2weights)\n",
    "    #print(\"layer2weights*weightmask=\", layer2weights*weightmask)\n",
    "    model.state_dict()['layer2.0.weight'].data.copy_(layer2weights*weightmask) #write pytorch structure back to model\n",
    "    #print(\"Xval=\", Xval)\n",
    "    Ypred1node=model(Xval) # Make Predictions based on the 1-node weights \n",
    "    #print(\"Ypred1node=\", Ypred1node)\n",
    "    #Plot modified 1-node model:\n",
    "    plt.plot(Xval.detach().numpy()[:,0],Ypred1node.detach().numpy()[:,0])\n",
    "plt.grid()      \n",
    "plt.legend(('Node 0', 'Node 1', 'Node2'));\n",
    " #We see the activation function fit with bias and weight \n",
    "#to different parts of the target function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We see the activation function of each node is fit with bias and weight to different parts of the target function. Since the activation function is only fitted over the training range, they all become flat after that, and hence their sum also becomes constant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Deep Function Approximator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/iqFrQbKNdO4?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/iqFrQbKNdO4?rel=0\" frameborder=\"0\" allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Instead of having a relatively flat network with only 3 layers, we can now distribute or nodes over more layers, each containing fewer nodes. In this way we obtain a more narrow and deeper network.\n",
    "\n",
    "In the example we have 5 layers, or 4 linear layers, but each layer has only 2 nodes, so the total number of nodes is similar:\n",
    "\n",
    "<img src='./images/02_02_neuralNetsApproDeep.png' width='800'>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Simple program to use a fully connected linear neural network layer as a 1-dimensional faunction y=f(x) approximator, using a deep network of several smaller layers instead of a wide layer.\n",
    "This could be for instance an audio signal, x would be the time, y would be the audio signal value.\n",
    "Gerald Schuller, Jan. 2020.\n",
    "--------------------------------------------\n",
    "Ported to Jupyter Notebook by Renato Profeta, Auguts 2020\n",
    "\"\"\"\n",
    "\n",
    "import torch \n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "device='cpu'\n",
    "#device='cuda'\n",
    "\n",
    "N=40 #number of samples in our signal\n",
    "Nodes=2 #Nodes in each layer\n",
    "#Nodes=80  #this can result in over-fitting\n",
    "\n",
    "#A multi-layer fully connected network, 1 input (time value), hidden layer has Nodes nodes, 1 output (function value).\n",
    "\n",
    "class LinNet(nn.Module):\n",
    "    #define and initialize the layers:\n",
    "    def __init__(self):\n",
    "        super(LinNet, self).__init__()\n",
    "        # Define the model. \n",
    "        #https://pytorch.org/docs/stable/nn.html?highlight=linear#torch.nn.Linear  \n",
    "        # Generate a fully connected linear neural network model, 2 layers, bias\n",
    "        # returns: Trainable object\n",
    "        self.layer1=nn.Sequential(nn.Linear(in_features=1, out_features=Nodes, bias=True))\n",
    "        self.layer2=nn.Sequential(nn.Linear(in_features=Nodes, out_features=Nodes, bias=True))\n",
    "        self.layer3=nn.Sequential(nn.Linear(in_features=Nodes, out_features=Nodes, bias=True))\n",
    "        self.layer4=nn.Sequential(nn.Linear(in_features=Nodes, out_features=1, bias=True))\n",
    "      \n",
    "        #self.act = nn.LeakyReLU() #non-linear activation function\n",
    "        #self.act = nn.ReLU() #non-linear activation function\n",
    "        #self.act = nn.Hardtanh() #non-linear activation function\n",
    "        self.act = nn.Sigmoid() #non-linear activation function\n",
    "      \n",
    "        #Putting the network together:\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        out = self.act(out)  #comment out if not desired\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        out = self.layer2(out)\n",
    "        #print(\"out.shape=\", out.shape)\n",
    "        out = self.act(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.act(out)\n",
    "        out = self.layer4(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide_input": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of input samples: 40 number of nodes: 2\n",
      "X.shape torch.Size([40, 1])\n",
      "Y.shape torch.Size([40, 1])\n",
      "Ypred.shape= torch.Size([40, 1])\n",
      "initial weights= OrderedDict([('layer1.0.weight', tensor([[0.6335],\n",
      "        [0.5824]])), ('layer1.0.bias', tensor([ 0.7903, -0.4966])), ('layer2.0.weight', tensor([[-0.0342, -0.3927],\n",
      "        [-0.2804, -0.2727]])), ('layer2.0.bias', tensor([-0.2253, -0.2949])), ('layer3.0.weight', tensor([[-0.6515,  0.1173],\n",
      "        [ 0.2142,  0.1056]])), ('layer3.0.bias', tensor([-0.5080,  0.0027])), ('layer4.0.weight', tensor([[ 0.5748, -0.4883]])), ('layer4.0.bias', tensor([0.6975]))])\n",
      "Define loss function:\n",
      "Define optimizer:\n",
      "Optimizing:\n",
      "0 0.9441583752632141\n",
      "1000 0.5360969305038452\n",
      "2000 0.431851863861084\n",
      "3000 0.05436243861913681\n",
      "4000 0.045526884496212006\n",
      "5000 0.044754479080438614\n",
      "6000 0.044330477714538574\n",
      "7000 0.04409246891736984\n",
      "8000 0.043904051184654236\n",
      "9000 0.04363683983683586\n",
      "10000 0.04311113804578781\n",
      "11000 0.04235917702317238\n",
      "12000 0.04145287722349167\n",
      "13000 0.04066087678074837\n",
      "14000 0.039813898503780365\n",
      "15000 0.03918961435556412\n",
      "16000 0.03884552791714668\n",
      "17000 0.03865858539938927\n",
      "18000 0.03853805735707283\n",
      "19000 0.03842571750283241\n",
      "20000 0.038297686725854874\n",
      "21000 0.038157958537340164\n",
      "22000 0.03802674263715744\n",
      "23000 0.03793161362409592\n",
      "24000 0.03787174075841904\n",
      "25000 0.03783418610692024\n",
      "26000 0.03780754655599594\n",
      "27000 0.03778531402349472\n",
      "28000 0.03776469826698303\n",
      "29000 0.03773524612188339\n",
      "30000 0.011874928139150143\n",
      "31000 0.009790265932679176\n",
      "32000 0.008754070848226547\n",
      "33000 0.008195171132683754\n",
      "34000 0.007900680415332317\n",
      "35000 0.007744056172668934\n",
      "36000 0.007649593986570835\n",
      "37000 0.007578557822853327\n",
      "38000 0.007520358078181744\n",
      "39000 0.007474121637642384\n",
      "40000 0.007438050117343664\n",
      "41000 0.007409709505736828\n",
      "42000 0.0073865302838385105\n",
      "43000 0.007368375547230244\n",
      "44000 0.007350594736635685\n",
      "45000 0.007335876114666462\n",
      "46000 0.007322967052459717\n",
      "47000 0.007311499677598476\n",
      "48000 0.007301219739019871\n",
      "49000 0.007291879504919052\n",
      "50000 0.007283403538167477\n",
      "51000 0.007275670766830444\n",
      "52000 0.0072687165811657906\n",
      "53000 0.007262243889272213\n",
      "54000 0.007257587276399136\n",
      "55000 0.007250864990055561\n",
      "56000 0.007245868444442749\n",
      "57000 0.007241242565214634\n",
      "58000 0.007236940320581198\n",
      "59000 0.007232952862977982\n",
      "60000 0.007229271344840527\n",
      "61000 0.007225836161524057\n",
      "62000 0.007223057560622692\n",
      "63000 0.007219627499580383\n",
      "64000 0.00721686240285635\n",
      "65000 0.007214250508695841\n",
      "66000 0.007211810909211636\n",
      "67000 0.007210762705653906\n",
      "68000 0.007207310758531094\n",
      "69000 0.007205282803624868\n",
      "70000 0.007203296758234501\n",
      "71000 0.007201500236988068\n",
      "72000 0.007199676241725683\n",
      "73000 0.007197992410510778\n",
      "74000 0.007196391932666302\n",
      "75000 0.007194865494966507\n",
      "76000 0.007193428929895163\n",
      "77000 0.007192005403339863\n",
      "78000 0.007190661039203405\n",
      "79000 0.00718992855399847\n",
      "80000 0.00718813668936491\n",
      "81000 0.007186939474195242\n",
      "82000 0.007185809314250946\n",
      "83000 0.007184918038547039\n",
      "84000 0.007190735079348087\n",
      "85000 0.007183194160461426\n",
      "86000 0.007181619759649038\n",
      "87000 0.007180701941251755\n",
      "88000 0.007179724983870983\n",
      "89000 0.007178833242505789\n",
      "90000 0.007177962455898523\n",
      "91000 0.007177545223385096\n",
      "92000 0.007176301442086697\n",
      "93000 0.007176665123552084\n",
      "94000 0.007174734957516193\n",
      "95000 0.007173971738666296\n",
      "96000 0.00717324111610651\n",
      "97000 0.007172534707933664\n",
      "98000 0.007171844597905874\n",
      "99000 0.007171256002038717\n",
      "100000 0.007170477416366339\n",
      "101000 0.007169825490564108\n",
      "102000 0.007169240154325962\n",
      "103000 0.007168562617152929\n",
      "104000 0.007167982868850231\n",
      "105000 0.007167384028434753\n",
      "106000 0.007166792638599873\n",
      "107000 0.007166221737861633\n",
      "108000 0.007165665738284588\n",
      "109000 0.007165130227804184\n",
      "110000 0.00716457050293684\n",
      "111000 0.007164058741182089\n",
      "112000 0.00716352229937911\n",
      "113000 0.007163024507462978\n",
      "114000 0.007162520196288824\n",
      "115000 0.007162030786275864\n",
      "116000 0.00716153671965003\n",
      "117000 0.007161051034927368\n",
      "118000 0.007160615175962448\n",
      "119000 0.007161037065088749\n",
      "120000 0.007159750908613205\n",
      "121000 0.007159245200455189\n",
      "122000 0.007158786989748478\n",
      "123000 0.007158344145864248\n",
      "124000 0.007157924585044384\n",
      "125000 0.007157499901950359\n",
      "126000 0.007157077081501484\n",
      "127000 0.007156668696552515\n",
      "128000 0.0071562593802809715\n",
      "129000 0.0071558705531060696\n",
      "130000 0.007158076856285334\n",
      "131000 0.0071550821885466576\n",
      "132000 0.007154707796871662\n",
      "133000 0.007155299186706543\n",
      "134000 0.007154299411922693\n",
      "135000 0.007154207676649094\n",
      "136000 0.00715442281216383\n",
      "137000 0.007154236547648907\n",
      "138000 0.007152592297643423\n",
      "139000 0.007152101956307888\n",
      "140000 0.00715226586908102\n",
      "141000 0.007151413708925247\n",
      "142000 0.007151052355766296\n",
      "143000 0.00715077156201005\n",
      "144000 0.007150431629270315\n",
      "145000 0.0071500628255307674\n",
      "146000 0.0071497089229524136\n",
      "147000 0.007149380631744862\n",
      "148000 0.007149063982069492\n",
      "149000 0.00714874779805541\n",
      "Loss on trainig set: 0.0071484298\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of input samples:\", N, \"number of nodes:\", Nodes)\n",
    "#input tensor, type torch tensor:\n",
    "#Indices: batch, additional dimensions, features or signal dimension. Here: 1 batch, 3 samples, signal dimension 2: \n",
    "#Training set:\n",
    "#The x input here is the time:\n",
    "X=torch.arange(0,N,1.0) #generates N time steps for X\n",
    "X=X.view(N,1) #adding the last dimension for the signal (1 sample each), first dimension for the batch of size N\n",
    "print(\"X.shape\", X.shape)\n",
    "#Target here is the (noisy) function value, a sine function + normal distributed random values:\n",
    "#Y=torch.sin(X)+torch.empty(X.shape).normal_(std=0.5)\n",
    "Y=torch.sin(X*3.14/N*2)+torch.randn(X.shape)*0.1\n",
    "#2 periods of the sinusoid in our training set, plus noise\n",
    "#Y=Y.view(N,1)\n",
    "print(\"Y.shape\", Y.shape)\n",
    "#Validation set, to test generalization, with new noise:\n",
    "Xval=torch.arange(0.5,2*N,1.0) #generates 2N time steps for X for extrapolation beyond N,\n",
    "#shifted by 0.5 compared to training set, \n",
    "#for interpolation between the original sample points.\n",
    "#print(\"Xval=\", Xval)\n",
    "Xval=Xval.view(2*N,1)\n",
    "#Validation Target:\n",
    "Yval=torch.sin(Xval*3.14/N*2)+torch.randn(Xval.shape)*0.1\n",
    "#Yval=Yval.view(2*N,1)\n",
    "   \n",
    "#create network object:\n",
    "model = LinNet().to(device)\n",
    "#Before training:\n",
    "Ypred=model(X) #the model produces prediction output\n",
    "print(\"Ypred.shape=\", Ypred.shape)\n",
    "weights = model.state_dict()   #read obtained weights\n",
    "print(\"initial weights=\", weights)  #see the random initialization of the weights \n",
    "   \n",
    "#print(\"model.parameters()=\", model.parameters()) \n",
    "   \n",
    "print(\"Define loss function:\")\n",
    "loss_fn = nn.MSELoss() #mean squared error loss\n",
    "   \n",
    "print(\"Define optimizer:\")\n",
    "#learning_rate = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "#optimizer = torch.optim.SGD(model.parameters(),lr=0.1)\n",
    "print(\"Optimizing:\")\n",
    "for epoch in range(150000):\n",
    "    Ypred=model(X) #the model produces prediction output\n",
    "    loss=loss_fn(Ypred, Y) #prediction and target compared by loss\n",
    "    if epoch%1000==0:\n",
    "        print(epoch, loss.item()) #print current loss value\n",
    "    optimizer.zero_grad() #optimizer sets previous gradients to zero\n",
    "    loss.backward() #optimizer computes new gradients\n",
    "    optimizer.step() #optimizer updates weights\n",
    "       \n",
    "Ypred=model(X) # Make Predictions based on the obtained weights \n",
    "#print(\"Ypred training set=\", Ypred) \n",
    "loss=loss_fn(Ypred, Y)\n",
    "print(\"Loss on trainig set:\", loss.detach().numpy())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "It turns out that the adam optimizer now needs many more iterations, 150000, instead of just 10000, hence 15 times as long, but the resulting function approximation seems to be more smooth. This is an **advantage for the generalization**, observe that the validation set now has a very similar loss as the training set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "It plots the following result for the training set:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(X.detach().numpy()[:,0],Y.detach().numpy()[:,0])\n",
    "plt.plot(X.detach().numpy()[:,0],Ypred.detach().numpy()[:,0])\n",
    "plt.legend(('Training Target', 'Prediction Output'))\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Training Result')\n",
    "plt.grid()\n",
    "Yvalpred=model(Xval) # Make Predictions based on the obtained weights \n",
    "#print(\"Y validation set=\", Yvalpred.detach().numpy()) \n",
    "loss=loss_fn(Yvalpred[:N,:], Yval[:N,:])\n",
    "print(\"Loss on validation set:\", loss.detach().numpy())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that the optimization has a harder time to fit the function, despite the 15 times more iterations. But often it is found that deep networks are better for the generalization, which should give the Loss for the validation and test similar values as for training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It plots the following for the validation set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weights= OrderedDict([('layer1.0.weight', tensor([[0.1475],\n",
      "        [0.5575]])), ('layer1.0.bias', tensor([-3.5223, -2.4937])), ('layer2.0.weight', tensor([[12.1843, -4.3992],\n",
      "        [10.8847, -8.8776]])), ('layer2.0.bias', tensor([ 0.6582, -2.2007])), ('layer3.0.weight', tensor([[-1.5357,  5.1039],\n",
      "        [19.0651, 95.6845]])), ('layer3.0.bias', tensor([ -1.7864, -18.6451])), ('layer4.0.weight', tensor([[16.3941, -0.7664]])), ('layer4.0.bias', tensor([-0.9849]))])\n",
      "model.state_dict()['layer2.0.weight']= tensor([[12.1843, -4.3992],\n",
      "        [10.8847, -8.8776]])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yval.detach().numpy()[:,0])\n",
    "plt.plot(Xval.detach().numpy()[:,0],Yvalpred.detach().numpy()[:,0])\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Generalization on Validation Set with Interpolation and Extrapolation')\n",
    "plt.legend(('Validation Target', 'Prediction Output'))\n",
    "plt.grid()\n",
    "   \n",
    "weights = model.state_dict()   #read obtained weights\n",
    "print(\"weights=\", weights)\n",
    "#Weights of layer 2:\n",
    "layer2weights=model.state_dict()['layer2.0.weight'].clone() #clone(), otherwise it is just a pointer!\n",
    "print(\"model.state_dict()['layer2.0.weight']=\", layer2weights)\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that it does a reasonable interpolation, with a smooth curve fitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#The resulting function from the network is the sum of the functions of the N nodes.\n",
    "#To see the functions of the individual nodes, we can just keep their weight unchanged, \n",
    "#set the others to zero, and plot the resulting function.\n",
    "#For that we make mask with zeros for the weights of layer 2, except for one node:\n",
    "\n",
    "plt.figure(figsize=(10,8))\n",
    "plt.xlabel('X- Input')\n",
    "plt.ylabel('Y-Output')\n",
    "plt.title('Basis Functions of the Network')\n",
    "for node in range(0,Nodes):\n",
    "    weightmask=torch.zeros(layer2weights.shape) #mask with all zeros for output layer, except one.\n",
    "    weightmask[0,node]=1.0 #node \"node\" unchanged\n",
    "    #print(\"weightmask\",weightmask)\n",
    "    #print(\"layer2weights=\",layer2weights)\n",
    "    #print(\"layer2weights*weightmask=\", layer2weights*weightmask)\n",
    "    model.state_dict()['layer2.0.weight'].data.copy_(layer2weights*weightmask) #write pytorch structure back to model\n",
    "    #print(\"Xval=\", Xval)\n",
    "    Ypred1node=model(Xval) # Make Predictions based on the 1-node weights \n",
    "    #print(\"Ypred1node=\", Ypred1node)\n",
    "    #Plot modified 1-node model:\n",
    "    plt.plot(Xval.detach().numpy()[:,0],Ypred1node.detach().numpy()[:,0])\n",
    "      \n",
    "#plt.legend(('Validation Target', 'Prediction Output', 'Node 0', 'Node 5'))\n",
    "plt.legend(('Node 0', 'Node 1', 'Node2'))\n",
    "plt.grid()\n",
    "#We see the activation function fit with bias and weight \n",
    "#to different parts of the target function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
